#include "Scene.h"
Scene::Scene(){

}
Scene::~Scene()
{
	for (m_mCollisionIterator = m_mCollisionMap.begin(); m_mCollisionIterator!= m_mCollisionMap.end();m_mCollisionIterator++ )
	{
		delete m_mCollisionIterator->second ;
	}

	for (m_mIterator = m_mapa.begin(); m_mIterator!= m_mapa.end();m_mIterator++ )
	{
		delete m_mIterator->second ;
	}

}
void Scene::SetName(std::string sName)
{
	m_sName = sName;
}
std::string Scene::GetName()
{
	return m_sName;
}
void Scene::Draw(Renderer* m_pkRender)
{
	m_mIterator = m_mapa.begin();
	while(m_mIterator!=m_mapa.end())
	{
		m_mIterator->second->Draw(m_pkRender);
		m_mIterator++;
	}
	onDraw (m_pkRender);

}
bool Scene::Add (std::string sNombre,Entity2D* pEntidad, std::string p_sColGroup)
{
	if(sNombre=="")
		return false;
	if(p_sColGroup=="")
		return false;
	m_mIterator = m_mapa.find(sNombre);
	if(m_mIterator != m_mapa.end())//si la entidad ya existe no hago nada
		return false;

	m_mCollisionIterator = m_mCollisionMap.find(p_sColGroup);
	if(m_mCollisionIterator == m_mCollisionMap.end())
	{
		//si el grupo de colision no existe lo creo
		AddColGroup (p_sColGroup);
	}
	AddEntityColGroup(pEntidad, p_sColGroup);
	pEntidad->SetCollisionGroup(p_sColGroup);//le seteo el grupo a la entidad		
	
	m_mapa[sNombre]=pEntidad;//la agrego en el mapa de entidades
	return true;
} 
void Scene::RemoveEntity(std::string sNombre)
{
	m_mapa.erase(sNombre);
}
void Scene::RemoveEntity(Entity2D* pEntity)
{
	m_mIterator = m_mapa.begin();
	while(m_mIterator != m_mapa.end())
	{
		if(m_mIterator->second==pEntity)
			m_mapa.erase(m_mIterator);
	}
}
Entity2D*Scene::GetEntity(std::string sNombre)
{
	m_mIterator = m_mapa.begin();
	m_mIterator = m_mapa.find(sNombre);
	return m_mIterator->second;
}
void Scene::Update(float p_fTimeBetweenFrames)
{
	CheckCollisions();
	m_mIterator = m_mapa.begin();
	while(m_mIterator != m_mapa.end())
	{
		m_mIterator->second->Update(p_fTimeBetweenFrames);
		m_mIterator++;
	}
	onUpdate(p_fTimeBetweenFrames);
}
void Scene::AddEntityColGroup(Entity2D* p_Entity, std::string p_ColGroup)
{

	for(m_mCollisionIterator = m_mCollisionMap.begin();m_mCollisionIterator != m_mCollisionMap.end();m_mCollisionIterator++)
	{
		if(m_mCollisionIterator->first==p_ColGroup)
		{
			std::vector<Entity2D*>* f_vGrupoActual = m_mCollisionIterator->second;
			f_vGrupoActual->push_back(p_Entity);
		}
	}
}
bool Scene::ChangeEntityColGroup (Entity2D* p_Entity, std::string p_NewGroup)
{
		if(p_NewGroup == "")
		return false;

		/////////---------------------------------------------------------------------------------------- falta hacer
}
bool Scene::AddColGroup (std::string p_sName)
{
	if(p_sName == "")
		return false;

	m_mCollisionIterator = m_mCollisionMap.find(p_sName);
	if(m_mCollisionIterator!=m_mCollisionMap.end())//si ya existe algun mapa con esa entidad
		return false;

	m_mCollisionMap[p_sName] = new std::vector<Entity2D*>(); //creo un grupo de colision nuevo
	return true;

}
bool Scene::RemColGroup (std::string p_sName)
{
	if(p_sName == "")
		return false;
}
void Scene::CheckCollisions()
{
	//--------------------------------------
	std::map<std::string,std::vector<Entity2D*>*>::iterator f_AuxColision;
	m_mCollisionIterator = m_mCollisionMap.begin();
	//--------------------------------------
	for(m_mCollisionIterator;m_mCollisionIterator != m_mCollisionMap.end();m_mCollisionIterator++)//grupo A
	{
		//--------------------------------------
		//obtengo todos los elementos del primer grupo 
		std::vector<Entity2D*>* listaA = m_mCollisionIterator->second;
		//obtengo el primer elemento del vector
		std::vector<Entity2D*>::iterator elementoA = listaA->begin();
		//Comparo ese elemento con todos los demas 
		//--------------------------------------
		for(elementoA;elementoA != listaA->end();elementoA++){
			//cada elemento debe colisionar con cualquier otro elemento de otro grupo
			for(f_AuxColision= m_mCollisionMap.begin()++;f_AuxColision != m_mCollisionMap.end();f_AuxColision++)//grupo B
			{
				//obtengo todos los elementos del segundo grupo 
				std::vector<Entity2D*>* listaB = f_AuxColision->second;
				//obtengo el primer elemento del primer vector del segundo grupo
				std::vector<Entity2D*>::iterator elementoB = listaB->begin();
				//checkeo cada elemento 
				for(elementoB;elementoB != listaB->end();elementoB++){
					Entity2D* A = *elementoA;
					Entity2D* B = *elementoB;
					if(A->CheckCollision(B)){
						A->OnCollision(B);
						B->OnCollision(A);
					}
					
				}				
			}
		}
	}
}